home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DApp / SeqPup.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-17  |  18.1 KB  |  708 lines  |  [TEXT/R*ch]
  1. // SeqPup.cp
  2. // d.g.gilbert -- biosequence editor & analysis platform
  3. // Jan 1994
  4.  
  5. #define UseGopher  0
  6.  
  7. #include <DClap.h>
  8. #if UseGopher
  9. #  include <DNet.h>
  10. #else
  11. #  include <DTCP.h>
  12. #  include <DSMTPclient.h>
  13. #  include <DSendMailDialog.h>
  14. #endif
  15. #include <DBio.h>
  16. #include <DRich.h>
  17. #include <DDrawPICT.h>
  18. #include <DSeqPict.h>
  19. #include <Dversion.h>
  20.  
  21. void AboutSeqPupPicture(); // DAboutSeqPup.cpp
  22.  
  23.  
  24.  
  25. class DSeqPup : public DApplication
  26. {
  27. public:
  28.     static char* kBugmailAddress;
  29.     static char* kGopherRTFDocSuffix;
  30.     
  31.     enum appMenus { kInternetMenu = 100, kPrefsMenu, kOpenMenu };  
  32.     enum menuCmds { 
  33.         kSeqPrefs=1001,  kOtherPrefs, kEditGopherMap,
  34.         kViewByDefault,kViewByDate,kViewBySize,kViewByName,kViewByKind,kViewByHost,
  35.         kViewAsText, kViewAsLink,
  36.         kOpenDoc, kFetchLink, kFetchDefault, // kFetchView1...kFetchViewN
  37.         kFetchOptionFlag, kAutoloadFlag,
  38.         kViewPrefs, kCodonPref,kREnzymePref,kColorPref,kStylePref,
  39.         kSaveWinPrefs,kSeqPrintPrefs, kSeqDocPrefs,
  40.         kGetInfo, kMailAdmin, kOpenLocalGo,
  41.         kNewServer,kFindServer,kNewLink, kEditLink,kExtractGodoc,kLockWindow,
  42.         kOpenText, kOpenSeq, kOpenAppendSeq, kOpenTree,  
  43.         kMailSetup, kSendMail, kBugMail
  44.         };
  45.  
  46.     DView *    fFetchOptionMenuItem;
  47.     DView *    fLockWinMenuItem;
  48.     DView * fAutoloadItem;
  49.     DMenu * fViewsMenu;
  50.     Boolean fWinPrefsNotSaved, fAppendSeq;
  51.     
  52.     void ISeqPup();     
  53.     virtual ~DSeqPup();
  54.     void DoAboutBox();
  55.  
  56.     virtual void SetUpMenus();    
  57.     virtual    Boolean IsMyAction(DTaskMaster* action);
  58.     virtual Boolean IsInternetMenu(DTaskMaster* action); 
  59.     virtual    void UpdateMenus(); 
  60.     virtual void OpenDocument(DFile* aFile);
  61.     virtual void OpenLocalGopher();
  62.     DWindow* DoMakeDocument(short itsCommandNumber, DFile* aFile);
  63. };
  64.  
  65.  
  66. char* DSeqPup::kBugmailAddress= "seqpup@bio.indiana.edu";
  67. char* DSeqPup::kGopherRTFDocSuffix = ".start";
  68.  
  69.  
  70.     // here we go -- the Nlm_Main() program (called from main() in ncbimain.c)
  71. extern "C" short Main(void)
  72. {
  73.   DSeqPup* app = new DSeqPup();
  74.   app->ISeqPup();
  75.   app->Run();
  76.   delete app; 
  77.   return 0;
  78. }
  79.  
  80.  
  81.  
  82. void DSeqPup::ISeqPup()
  83. {
  84.     DApplication::kName= "SeqPup";
  85.     DApplication::kVersion= (char*) kDCLAPVersionString; //" v 0.4";
  86.     
  87.     fFetchOptionMenuItem= NULL;
  88.     fLockWinMenuItem= NULL;
  89.     fWinPrefsNotSaved= true;
  90.     fAppendSeq= false;
  91.     fAutoloadItem = NULL;
  92. #if UseGopher
  93.     gGopherDoc = NULL; // ??? this should be set, but isn't in 68K ??
  94. #endif
  95.     fViewsMenu= NULL;
  96.     fFileSuffix = NULL; // unix, msdos file suffix
  97.     fAcceptableFileTypes = NULL;     // really want "IGo4 BKMK TEXT" and perhaps others
  98.                                                                 // but NCBI tools only handle 1 type now
  99.     IApplication();
  100.     
  101. #if UseGopher
  102.         // network doc initializations
  103.     InitializeUGopher();
  104.     DGoviewPrefs::InitGlobals();
  105.     DGoOtherPrefs::InitGlobals();
  106.     if (fFetchOptionMenuItem) fFetchOptionMenuItem->SetStatus(DGopherListDoc::gOptionIsOn);
  107.     if (fAutoloadItem) fAutoloadItem->SetStatus(DGoLinkedTextDoc::gAutoloadInlines);
  108. #endif
  109.  
  110.     DRichView::InitRichView();
  111.     
  112.         // sequence initializations
  113.     DSeqDoc::GetGlobals(); //SeqDocPrefs(kSeqDocPrefInit);
  114.     DCodons::Initialize("codon","data","tables:codon.table");
  115.     DREMap::Initialize("renzyme","data","tables:renzyme.table");
  116.     DBaseColors::Initialize("color","data","tables:color.table");
  117.     if (DBaseColors::NotAvailable()) ; // read in DBaseColors data now 
  118.     DStyleTable::Initialize("seqmasks","data","tables:seqmasks.table");
  119.     if (DStyleTable::NotAvailable()) ; // read in DStyleTable data now 
  120.     
  121.         // default documents ??
  122.     if (DSeqDoc::fgStartDoc) DSeqDoc::NewSeqDoc();
  123.     {
  124.         // open default gopher document if it exists.
  125.         // TRY RTF Form first (.start ?? )
  126.         // open both default.go4 and default.start files, if they exist !
  127.     char godefault[512];
  128. #if UseGopher
  129.     StrNCpy(godefault, (char*)Shortname(), 512);    
  130.     StrNCat(godefault, DGopherListDoc::kGopherDocSuffix, 512);
  131.     DApplication::OpenDocument( (char*)godefault);
  132. #endif
  133.     StrNCpy(godefault, (char*)Shortname(), 512);    
  134.     StrNCat(godefault, kGopherRTFDocSuffix, 512);
  135.     DApplication::OpenDocument( (char*)godefault);
  136.     }
  137.  
  138. }     
  139.  
  140.  
  141. DSeqPup::~DSeqPup()
  142. {
  143. #if UseGopher
  144.     DGoviewPrefs::SaveGlobals();
  145.     DGoOtherPrefs::SaveGlobals();
  146. #endif
  147.     if (fWinPrefsNotSaved) DSeqDoc::SaveGlobals(); 
  148.     DDrawPict::Cleanup();
  149. }
  150.  
  151.  
  152. void DSeqPup::DoAboutBox()
  153. {
  154. #if !defined(WIN_MSWIN) && !defined(WIN_MOTIF)
  155.         // problems yet w/ this large codepic in mswin(WIN16) and unix/motif
  156.     AboutSeqPupPicture();
  157. #else
  158.     char aboutMe[512];
  159.     sprintf( aboutMe, "SeqPup, version %s"LINEEND
  160.                 " a biosequence editor & analysis application "LINEEND
  161.                 " copyright by D.G. Gilbert, 1990-1995"
  162.                 , DApplication::kVersion);
  163.     DAboutBoxWindow* about = new DAboutBoxWindow(aboutMe);
  164. #endif
  165. }
  166.  
  167.  
  168. void DSeqPup::SetUpMenus(void)
  169. {
  170.     //DApplication::SetUpMenus();
  171.  
  172.     DMenu* aMenu = NULL;
  173. #ifdef WIN_MAC
  174.     DAppleMenu* appleMenu = new DAppleMenu(this,fAboutLine);
  175. #endif
  176.     if (!aMenu) aMenu = this->NewMenu( cFileMenu, "File");
  177. #ifndef WIN_MAC
  178.     aMenu->AddItem(kAbout, fAboutLine);
  179.     aMenu->AddSeparator();
  180. #endif
  181.     aMenu->AddItem(kNew,"New/N", false, true);
  182.  
  183.     aMenu->AddItem( kOpenSeq, "Open sequence.../O",false, true);
  184.     //aMenu->AddItem(kOpen,"Open.../O",false, true);
  185.     DMenu* oMenu= new DSubMenu( kOpenMenu, aMenu, "Open other");
  186.     //oMenu->AddItem( kOpenSeq, "Sequence file.../O",false, true);
  187.     oMenu->AddItem( kOpenText, "Text,RTF,Image...",false, true);
  188.     oMenu->AddItem( kOpenAppendSeq, "Append sequence...",false, true);
  189.     //oMenu->AddItem( kOpenTree, "Phylogenetic tree...",false, true);
  190.     //oMenu->AddItem( kOpenLocalGo,"Open Local gopher...",false, true);
  191.     //oMenu->AddItem( kNewServer,"Open Remote.../R",false, true);
  192.  
  193.     aMenu->AddSeparator();
  194.     aMenu->AddItem(kClose,"Close/W",false, true);
  195.     aMenu->AddItem(kSave,"Save/S",false, true);
  196.     aMenu->AddItem(kSaveAs,"Save As...",false, true);
  197.     aMenu->AddItem(DSeqDoc::cSaveSel,"Save selection...",false, true);
  198.     aMenu->AddSeparator();
  199.     aMenu->AddItem(kPrint,"Print",false, true);
  200.     aMenu->AddItem(kHelp,"Help/H",false, true);
  201.     aMenu->AddSeparator();
  202.     aMenu->AddItem(kQuit,"Quit/Q",false, true);
  203.  
  204.     aMenu= NULL;
  205.     this->SetUpMenu(DApplication::cEditMenu, aMenu);
  206.     DSeqDoc::SetUpMenu(DApplication::cEditMenu, aMenu);
  207.  
  208.     DMenu* sMenu = NULL;
  209.     DSeqDoc::SetUpMenu(DSeqDoc::kSeqMenu, sMenu);
  210.  
  211.     DMenu* iMenu = NewMenu( kInternetMenu, "Internet");
  212.     //iMenu->AddItem( kMailSetup, "Mail setup...");
  213.      //iMenu->AddSeparator();        
  214.  
  215.     DSeqDoc::SetUpMenu(DSeqDoc::kInternetMenu, iMenu);
  216.      
  217.     iMenu->AddItem( kSendMail, "Send Mail...");
  218.     iMenu->AddItem( kBugMail, "Comment on this app...");
  219.  
  220.     DMenu* cMenu = NULL;
  221.     DSeqApps::SetUpMenu(DSeqApps::kChildMenu, cMenu);
  222.     
  223.     iMenu = NewMenu( kPrefsMenu, "Options");
  224.     iMenu->AddItem( kSeqDocPrefs, "Seq Prefs...",false, true);
  225.     iMenu->AddItem( kSeqPrintPrefs, "SeqPrint Prefs...", false, true); 
  226.     iMenu->AddItem( kColorPref, "Base color table...", false, true);
  227.     iMenu->AddItem( kStylePref, "Base style table...", false, true);
  228.     iMenu->AddItem( kCodonPref, "Codon table...", false, true);
  229.     iMenu->AddItem( kREnzymePref, "R.Enzyme table...", false, true);
  230.     iMenu->AddItem( kSaveWinPrefs, "Save window settings", false, true);
  231.     // add opt to save current aln window size,text-lock,color-state to prefs ?
  232.     // or do automatically on close?
  233.     iMenu->AddSeparator();
  234.     
  235. #if UseGopher
  236.     iMenu->AddItem( kViewPrefs, "View Prefs...", false, true); 
  237. #if NETSTUF_LATER
  238.     iMenu->AddItem( kFetchOptionFlag, "Fetch with options", true, true);
  239.         // we can only access menu item thru gViewCentral now the way DMenu::AddItem() is written...
  240.     fFetchOptionMenuItem= (DView*) gViewCentral->GetView(kFetchOptionFlag);
  241.  
  242.     iMenu->AddItem( kAutoloadFlag, "Autoload images", true, true);
  243.     fAutoloadItem= (DView*) gViewCentral->GetView(kAutoloadFlag);
  244.     iMenu->AddItem( kEditGopherMap, "Edit view handlers...",false, true);
  245.     iMenu->AddItem( kOtherPrefs,     "Other prefs...",false, true);
  246. #endif
  247. #endif
  248.     iMenu->AddItem( kMailSetup,     "Mail setup...",false, true);
  249.  
  250.     aMenu= NULL;
  251.     this->SetUpMenu(DApplication::cWindowMenu, aMenu);
  252. }
  253.  
  254.  
  255.  
  256.  
  257.  
  258. class    DBugMailDialog : public DSendMailDialog
  259. {
  260. public:
  261.     DBugMailDialog(long id, DTaskMaster* itsSuperior,
  262.         short width = -5, short height = -5, short left = -50, short top = -20, char* title = NULL):
  263.         DSendMailDialog(id, itsSuperior, width, height, left, top, title)
  264.         {}
  265.  
  266.     virtual DView* InstallTo(DView* super, char* toStr)  //override
  267.     {
  268.         return DSendMailDialog::InstallTo(super, DSeqPup::kBugmailAddress);
  269.     }
  270. };
  271.  
  272.  
  273.  
  274. #if UseGopher
  275. class DLocalDialog : public DWindow
  276. {
  277. public:
  278.     enum { kSetDefault = 13345 };
  279.     DEditText* fQuery;
  280.     DLocalDialog();            
  281.     char* Result();
  282.     void OkayAction();
  283. };
  284.  
  285.  
  286. DLocalDialog::DLocalDialog() :
  287.     DWindow( 0, gApplication, fixed, -10, -10, -50, -20, "Local Gopher", kDontFreeOnClose)
  288. {
  289.         new DPrompt(0, this, "Open local folder?", 0, 0, Nlm_systemFont);             
  290.         this->NextSubviewBelowLeft();
  291.         fQuery= new DEditText(0, this, gLocalGopherRoot, 28); 
  292.         this->SetEditText(fQuery);
  293.         this->NextSubviewBelowLeft();
  294.         (void) new DCheckBox(kSetDefault,this,"Make this default local services folder");
  295.         this->AddOkayCancelButtons();
  296. }
  297.             
  298. void DLocalDialog::OkayAction() 
  299. { 
  300.     DWindow::OkayAction();
  301.     DCheckBox* ck = (DCheckBox*) this->FindSubview(kSetDefault);
  302.     if (ck && ck->GetStatus()) {
  303.         char* newroot= fQuery->GetText(); // this dups text
  304.         if (newroot) {
  305.             MemFree(gLocalGopherRoot);
  306.             gLocalGopherRoot= newroot;
  307.             }
  308.         }
  309. }
  310.  
  311. char* DLocalDialog::Result()
  312. {
  313.     if (fOkay) return fQuery->GetText();
  314.     else return NULL;
  315. }
  316. #endif
  317.  
  318.  
  319. void DSeqPup::OpenLocalGopher()
  320. {
  321. #if UseGopher
  322.     DLocalDialog* win= new DLocalDialog();
  323.     if ( win->PoseModally() ) {
  324.         char* localpath= win->Result();
  325.       DGopher* localgo= DGopherList::LocalGopher( localpath);
  326.         MemFree( localpath);
  327.       DGopherListDoc::ProcessGopher( localgo, 0);
  328.       }
  329.     delete win;  
  330. #endif
  331. }
  332.         
  333.  
  334.  
  335. void DSeqPup::OpenDocument(DFile* aFile)
  336. {
  337.     if (!aFile || !aFile->Exists()) return;
  338.     gCursor->watch();
  339.     if (DSeqDoc::IsSeqFile(aFile)) {
  340.         if (fAppendSeq) {
  341.             DSeqDoc* sdoc= (DSeqDoc*) gWindowManager->CurrentWindow();
  342.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) 
  343.                 sdoc->Open(aFile);   
  344.             else
  345.                 fAppendSeq= false;
  346.             }
  347.         if (!fAppendSeq) {
  348.             DSeqDoc* sdoc= new DSeqDoc(DSeqDoc::kSeqdoc, NULL, NULL);
  349.             sdoc->Open(aFile);   
  350.             }
  351.         }
  352.         
  353.     else {
  354.         aFile->Close();
  355. #if UseGopher
  356.       DGopher* localgo= DGopherList::LocalGopher( aFile);
  357.       DGopherListDoc::ProcessGopher( localgo, 0);
  358. #else
  359.         DRichTextDoc* doc= new DRichTextDoc( 0, true, gTextFont);
  360.         doc->Open( aFile);
  361. #endif
  362.         }
  363.     gCursor->arrow();
  364. }
  365.  
  366.  
  367.  
  368. DWindow* DSeqPup::DoMakeDocument(short itsCommandNumber, DFile* aFile)
  369. {
  370.     DWindow* theDoc= NULL;
  371.     
  372.      switch (itsCommandNumber) {
  373. #if 0
  374.         case cOpenNAColors:
  375.         case cOpenAAColors: {
  376.             DColorPrefDocument* aDoc= new DColorPrefDocument();
  377.             if (itsCommandNumber == cOpenAAColors)
  378.                 aDoc->IColorPrefDocument( itsFile, kAmino);
  379.             else 
  380.                 aDoc->IColorPrefDocument( itsFile, kDNA);
  381.             return aDoc;
  382.             }
  383.  
  384.         case cOpenTree: {
  385.             DTreeDoc* aDoc= new DTreeDoc();
  386.             aDoc->ITreePrintDocument(kPrintClipType, NULL, NIL, itsFile);
  387.             return aDoc;
  388.             }
  389.         
  390.         // also handle gopher documents ... some gopher method should do this
  391.         
  392.         default:  { //== cNewProj/cOpenProj, cNew/cOpen
  393.             DAlnDoc* aDoc= new DAlnDoc();
  394.             aDoc->IAlnDoc( itsFile);
  395.             return aDoc;
  396.             }
  397. #endif
  398.         }
  399.         
  400.     return theDoc;
  401. }
  402.  
  403.  
  404.  
  405.  
  406.  
  407.         
  408. Boolean DSeqPup::IsInternetMenu(DTaskMaster* action) 
  409. {
  410.     DWindow* win;
  411.     DSeqDoc* sdoc = (DSeqDoc*) gWindowManager->CurrentWindow();
  412.  
  413.     switch(action->Id()) {
  414.  
  415.         case kCodonPref: 
  416.             DCodons::TableChoice();
  417.             return true;
  418.  
  419.         case kColorPref: 
  420.             DBaseColors::TableChoice();
  421.             return true;
  422.  
  423.         case kStylePref: 
  424.             DStyleTable::TableChoice();
  425.             return true;
  426.             
  427.         case kREnzymePref: 
  428.             DREMap::TableChoice();
  429.             return true;
  430.             
  431.         case kSaveWinPrefs: 
  432.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) {
  433.                 sdoc->MakeGlobalsCurrent();
  434.                 DSeqDoc::SaveGlobals();
  435.                 fWinPrefsNotSaved= false;
  436.                 }
  437.             return true;
  438.  
  439.         case kSeqDocPrefs: 
  440.             SeqDocPrefs(kSeqDocPrefDialog);
  441.             return true;
  442.     
  443.         case kSeqPrintPrefs: 
  444.             SeqPrintPrefs(kSeqPrintPrefDialog);
  445.             return true;
  446.  
  447. #if UseGopher
  448.         case kViewPrefs: 
  449.             if (!gGoviewPrefs) {
  450.                 gGoviewPrefs = new DGoviewPrefs();
  451.                 gGoviewPrefs->Initialize();
  452.                 }
  453.             if (gGoviewPrefs && gGoviewPrefs->PoseModally()) ;
  454.             //delete gGoviewPrefs; // leave the window hidden but alive for later use
  455.             return true;
  456.             
  457.         case kOtherPrefs:
  458.             if (!gGoOtherPrefs) {
  459.                 gGoOtherPrefs = new DGoOtherPrefs();
  460.                 gGoOtherPrefs->Initialize();
  461.                 }
  462.             if (gGoOtherPrefs && gGoOtherPrefs->PoseModally()) ;
  463.             //delete gGoOtherPrefs; // leave the window hidden but alive for later use
  464.             return true;
  465.  
  466.         case  kFetchOptionFlag:
  467.             if (fFetchOptionMenuItem) DGopherListDoc::gOptionIsOn= fFetchOptionMenuItem->GetStatus();
  468.             else DGopherListDoc::gOptionIsOn = !DGopherListDoc::gOptionIsOn; // or read menu state
  469.             return true;
  470.  
  471.         case  kAutoloadFlag:
  472.             if (fAutoloadItem) DGoLinkedTextDoc::gAutoloadInlines= fAutoloadItem->GetStatus();
  473.             else DGoLinkedTextDoc::gAutoloadInlines = !DGoLinkedTextDoc::gAutoloadInlines; // or read menu state
  474.             return true;
  475.  
  476.         case  kExtractGodoc:
  477.             {
  478.             win= gWindowManager->CurrentWindow();
  479.             if (win && win->Id() == DGoLinkedTextDoc::kGoLitextdoc) {
  480.                 DGoLinkedTextDoc* ndoc= (DGoLinkedTextDoc *) win;
  481.                 switch (action->Id()) {
  482.                     case kExtractGodoc    : ndoc->ExtractGopherDoc(); break;
  483.                     }
  484.                 }
  485.             return true;
  486.             }
  487.  
  488.  
  489.         case  kLockWindow:
  490.             win= gWindowManager->CurrentWindow();
  491.             if (win && fLockWinMenuItem) {
  492.                 if (win->Id() == DGopherListDoc::kGoListdoc)
  493.                      ((DGopherListDoc *) win)->PinWindow( fLockWinMenuItem->GetStatus());
  494.                 else if (win->Id() == DGopherTextDoc::kGoTextdoc   
  495.                             || win->Id() == DGoLinkedTextDoc::kGoLitextdoc)  
  496.                     ((DGopherTextDoc *) win)->PinWindow( fLockWinMenuItem->GetStatus());
  497.                 }         
  498.             return true;
  499. #endif
  500.  
  501. #if UseGopher
  502.         case     kGetInfo:
  503.         case  kFetchLink:
  504.         case  kMailAdmin:
  505.         case    kFindServer:
  506.         case    kNewServer:
  507.         case    kNewLink:
  508.         case  kEditLink:
  509.             {
  510.             win= gWindowManager->CurrentWindow();
  511.             if (win && win->Id() == DGopherListDoc::kGoListdoc) {
  512.                 DGopher* go;
  513.                 short iview;
  514.                 DGopherListDoc* gdoc= (DGopherListDoc *) win;
  515.                 switch (action->Id()) {
  516.  
  517.                     case kFindServer:    gdoc->TopOfGopherHole(); break;
  518.                     case kNewServer    : gdoc->InsertNewGopher( false); break;
  519.                     case kNewLink        : gdoc->InsertNewGopher( true); break;
  520.                     case kEditLink    : gdoc->EditOldGopher(); break;
  521.                     case kGetInfo:
  522.                         iview= DGopher::kGetItemInfo;
  523.                             // fall thru to kFetchLink
  524.                     case kFetchLink:
  525.                         go= gdoc->fGoview->SelectedGopher();
  526.                         if (go) gdoc->ProcessGopher(go, iview);
  527.                         break;
  528. #if 0                    
  529.                     case kMailAdmin    :
  530.                         go= gdoc->fGoview->SelectedGopher();
  531.                         if (go && go->fAdminEmail) {
  532.                             win= new DAdminMailDialog(0, this, go);
  533.                             win->Open();
  534.                             }
  535.                         break;
  536. #endif
  537.                     }
  538.                 }
  539.             return true;
  540.             }
  541. #endif
  542.  
  543.          case    kMailSetup:
  544.             {
  545.             win= new DMailSetupDialog(0, this, -10, -10, -20, -20, "Mail Setup");
  546.             win->Open();
  547.             return true;
  548.             }
  549.         case     kSendMail: 
  550.             {
  551.             win= new DSendMailDialog(0, this, -10, -10, -20, -20, "Send Mail");
  552.             win->Open();
  553.             return true;
  554.             }
  555.         case  kBugMail:
  556.             {
  557.             win= new DBugMailDialog(0, this, -10, -10, -20, -20, "Comment about this App");
  558.             win->Open();
  559.             return true;
  560.             }
  561.             
  562.         default:    
  563.             if (sdoc && sdoc->Id() == DSeqDoc::kSeqdoc) 
  564.                 return sdoc->IsMyAction(action);
  565.             else return false;
  566.         }
  567. }
  568.  
  569.  
  570. Boolean DSeqPup::IsMyAction(DTaskMaster* action) 
  571. {
  572.     enum doctype { nodoc, anydoc, godoc, seq1doc, alndoc };
  573.     doctype    thedoc = nodoc;
  574.     Boolean    done= false;
  575.     
  576.     DWindow* win     = gWindowManager->CurrentWindow();
  577.     DSeqDoc* sdoc = (DSeqDoc*) win;
  578.     DSeqedWindow* s1doc= (DSeqedWindow*) win;
  579. #if UseGopher
  580.     DGopherListDoc* gdoc = (DGopherListDoc*) win;
  581. #endif
  582.     if (win) {
  583.         if (win->Id() == DSeqDoc::kSeqdoc) thedoc = alndoc;
  584.         else if (win->Id() == DSeqedWindow::kId) thedoc = seq1doc;
  585. #if UseGopher
  586.         else if (win->Id() == DGopherListDoc::kGoListdoc) thedoc = godoc;
  587. #endif
  588.         else thedoc= anydoc;
  589.         }
  590.         
  591.     short    menuitem = action->Id();
  592.           
  593.     if (action->fSuperior)  
  594.         switch (action->fSuperior->Id()) {
  595.  
  596.             case kOpenMenu : 
  597.             case cFileMenu : 
  598.               switch (menuitem) {
  599.               
  600.                 case kNewServer:
  601.                     return IsInternetMenu(action);
  602.                     
  603.                 case DSeqDoc::cSaveSel:
  604.                     goto caseSeqDoc;
  605.                     
  606.                 case DApplication::kNew:
  607.                     DSeqDoc::NewSeqDoc();
  608.                     return true;
  609.                     
  610.                 case kOpenText:
  611.                     DApplication::DoMenuTask(DApplication::kOpen, NULL);
  612.                     return true;
  613.                     
  614.                 case kOpenTree:
  615.                     return true;
  616.                     
  617.                 case kOpenAppendSeq:
  618.                     fAppendSeq= true;
  619.                 case kOpenSeq:
  620.                 case DApplication::kOpen:
  621.                     DSeqDoc::fgTestSeqFile= true; // ???
  622.                     DApplication::DoMenuTask(DApplication::kOpen,NULL);
  623.                     DSeqDoc::fgTestSeqFile= false;
  624.                     fAppendSeq= false;
  625.                     return true;
  626. #if UseGopher
  627.                 case kOpenLocalGo:
  628.                     OpenLocalGopher();
  629.                     return true;
  630. #endif
  631.                  default: 
  632.                     return DApplication::IsMyAction(action);
  633.                 }
  634.                 break;
  635.         
  636.         
  637.             case DApplication::cEditMenu:
  638. #if 1
  639.                 if (thedoc == alndoc) done= sdoc->IsMyAction(action);
  640.                 else if (thedoc == seq1doc) done= s1doc->IsMyAction(action);
  641.                 else done= false;
  642.                 if (done) return true;
  643. #else
  644.                 if (menuitem == DSeqDoc::cFindORF) {
  645.                     if (thedoc == alndoc) return sdoc->IsMyAction(action);
  646.                     else if (thedoc == seq1doc) return s1doc->IsMyAction(action);
  647.                     }
  648. #endif
  649.                 break;
  650.                 
  651.             case kInternetMenu    :
  652.             case kPrefsMenu : 
  653. #if UseGopher
  654.                 if (menuitem == DGopherListDoc::kViewChoiceMenu) 
  655.                     goto caseViewChoiceMenu; 
  656.                 else
  657. #endif
  658.                   return IsInternetMenu(action);
  659.                 
  660. #if UseGopher
  661.             case DGopherListDoc::kViewKindMenu    : 
  662.                 if (thedoc == godoc) return gdoc->IsMyAction(action);
  663.                 else return false;
  664.                 
  665.             case DGopherListDoc::kViewChoiceMenu    : 
  666.             caseViewChoiceMenu:
  667.                 if (thedoc == godoc) return gdoc->IsMyAction(action);
  668.                 else return false;
  669. #endif
  670.             
  671.             case DSeqApps::kChildMenu :
  672.                 // ?? do we always need DSeqDoc window active for childmenus ??
  673.             case DSeqDoc::kSeqMenu    : 
  674.             case DSeqDoc::kViewKindMenu    : 
  675.             case DSeqDoc::kSeqMaskMenu    : 
  676.             caseSeqDoc:
  677.                 switch(menuitem) {
  678.                     case DSeqDoc::cNAcodes:    NucCodesPicture(); return true;
  679.                     case DSeqDoc::cAAcodes: AminoCodesPicture(); return true;
  680.                     }
  681.                 if (thedoc == alndoc) return sdoc->IsMyAction(action);
  682.                 else if (thedoc == seq1doc) return s1doc->IsMyAction(action);
  683.                 else return false;
  684.             }
  685.      
  686.      
  687.     switch(menuitem) {
  688.  
  689.         case DApplication::kNew:
  690.             DSeqDoc::NewSeqDoc();
  691.             return true;
  692.         default: 
  693.             return DApplication::IsMyAction(action);
  694.         }
  695. }
  696.  
  697.  
  698.  
  699. void DSeqPup::UpdateMenus(void)
  700. {
  701.     DApplication::UpdateMenus();
  702.     
  703.     //gViewCentral->EnableView(kSpecial1);
  704.     //gViewCentral->EnableView(kSpecial2);
  705. }
  706.  
  707.  
  708.